import wx
import re
import sys
from pyDemin import *
from client import *
from wxPython.lib.dialogs import *
import wx.lib.newevent

(New,EVT_TEST)=wx.lib.newevent.NewEvent()


console=True

#classe d'affichage du demineur
class DeminWindowReseau(wx.Panel):
    def __init__(self, parent, ID,partie,nomJ):
        wx.Panel.__init__(self,parent,ID)
        self.SetSize(parent.GetClientSize())
        self.wm=30
        self.hm=30

        #recuperation des donnees relatives a la partie
        self.nomPartie=partie[0]
        self.nbJoueurs=partie[1]
        self.difficulte=partie[2]
        self.nomJoueurs=partie[3]
        self.compteurs=[0]*self.nbJoueurs
        self.nomJ=nomJ

        print partie[3]
        print self.nomJoueurs
        
        #determine si joueur doit demarrer la partie ou pas
        self.premier=False
        self.atoi=False
        if self.nomJ==self.nomJoueurs[0]:
            self.premier=True
            self.atoi=True

        if re.search("^[0-9]",self.difficulte)!=None:
            self.difficulte=int(self.difficulte)
            self.nb=self.difficulte*45-(self.difficulte-1)*5#determination du nb de mines dans le jeu
        elif self.difficulte=="Facile":
            self.nb=45
        elif self.difficulte=="Moyen":
            self.nb=85
        else:
            self.nb=120

        self.game=pyDemin(30,30,self.nb)#initialisation du jeu en lui-meme

        self.parent=parent

        self.init_buffer()#initialisation du buffer

        self.Bind(wx.EVT_PAINT,self.OnPaint)
        self.Bind(wx.EVT_LEFT_DOWN,self.OnLeft)
        self.Bind(wx.EVT_RIGHT_DOWN,self.OnRight)
        self.Bind(wx.EVT_CLOSE,self.Close)


    def Close(self,evt):#le joueur choisi de quitter la partie
        msg=wx.MessageDialog(self,"\n Etes-vous sur de vouloir quitter la partie ?","Attention",wx.YES_NO)
        rep=msg.ShowModal()
        msg.Destroy()
        if rep==5103:#s'il clique sur ok
            msg=wx.MessageDialog(self,"\n Vous allez etre redirige vers l'accueil","Attention",wx.OK)
            rep=msg.ShowModal()
            msg.Destroy()
            self.parent.client.mySocketEmission.send("quitte")
            self.parent.client.mySocketEmission.send(self.nomJ)
            self.parent.Destroy()
        
        
        
    def OnLeft(self,evt):#quand le joueur clique gauche
        if self.atoi:
            x,y = evt.GetPosition()
            a=x/20
            b=y/20
            if self.premier:#si le joueur doit demarrer la partie
                self.game.debut(a,b)#1er clic, qui ne doit pas etre sur une bombe
                matrice=self.game.mine#recuperation de la matrice des bombes
            #envoi au serveur qui la transmet aux autres joueurs
                self.parent.client.mySocketEmission.send("matrice")
                self.parent.client.mySocketEmission.send(matrice)
                self.premier=False
            else:#sinon
                self.game.decouvre(a,b)#decouvrement la grille
            mm=self.refresh(a,b,"left")#rafraichissement de la fenetre
            self.parent.SetStatusText("Il reste %d mines"%(self.nb-mm))
        else:
            msg=wx.MessageDialog(self,"\n Ce n'est pas votre tour","Attention",wx.OK|wx.ICON_ERROR)
            rep=msg.ShowModal()
            msg.Destroy()

    def OnRight(self,evt):#quand le joueur clique droit
        if self.atoi:
            x,y = evt.GetPosition()
            a=x/20
            b=y/20
            self.game.aamine(a,b)#enregistrement du fait qu'il veut marquer la case
            mm=self.refresh(a,b,"right")#raffraichissement de la fenetre
            self.parent.SetStatusText("Il reste %d mines"%(self.nb-mm))
            self.atoi=False
        else:
            msg=wx.MessageDialog(self,"\n Ce n'est pas votre tour","Attention",wx.OK|wx.ICON_ERROR)
            rep=msg.ShowModal()
            msg.Destroy()
                
    def OnPaint(self,evt):
        dc = wx.BufferedPaintDC(self,self.buffer)
    
    def init_buffer(self):#initialisation du buffer
        print "pas encore plante"
        w,h = self.GetClientSize()
        self.buffer = wx.EmptyBitmap(600,600)
        dc = wx.BufferedDC(wx.ClientDC(self),self.buffer)
        self.draw(dc)
        print "je suis la"
        #affichage des compteurs et du nom de la partie
        cb=wx.StaticText(self,19,"Partie : "+ self.nomPartie,(680,50),size=(270,40))
        print "ici?"
        self.Compteurs()
        print "et la?"

    def Compteurs(self):#affichae des compteurs des joueurs
        print self.nbJoueurs
        for i in range(self.nbJoueurs):
            print self.nomJoueurs
            cb=wx.StaticText(self,19,self.nomJoueurs[i],(640,135+i*60),size=(100,50))
            txtP=wx.TextCtrl(self,30,str(self.compteurs[i]),(800,130+i*60),size=(50,30))
        
	
    def draw(self,dc):#dessin du fond quadrille de la fenetre
        dc.Clear()
        dc.SetBrush(wx.Brush("grey"))
        dc.SetPen(wx.Pen("black",1))
        for i in range(30):
            for j in range(30):
                dc.DrawRectangle(i*20,j*20,20,20)

    def decouvrir(self,x,y,nom,typ):#decouvrement quand c'est un autre joueur
        if typ=="left":#si c'est 1 clic gauche
            self.game.decouvre(x,y)#decouvrement de la grille
        else:#sinon
            self.game.aamineAJ(x,y)#enregistrement d'une bombe decouverte par 1 autre joueur
        mm=self.refresh(x,y,nom,typ)#rafraichissement
        self.parent.SetStatusText("Il reste %d mines"%(self.nb-mm))

    def refresh(self,a,b,typ):#rafraichissement de la fenetre
        dc = wx.BufferedDC(wx.ClientDC(self),self.buffer)
        dc.Clear()
        dc.SetPen(wx.Pen("black",1))
        t=True
        nb=0
        mm=0
        for i in range(30):
            for j in range(30):
                if t:
                    if self.game.dec[j*self.game.w+i]==0:#si la case n'est pas decouverte
                        dc.SetBrush(wx.Brush("grey"))
                        dc.DrawRectangle(i*20,j*20,20,20)
                    elif self.game.dec[j*self.game.w+i]==-1:#si la case est marquee, par le joueur
                        if self.game.mine[j*self.game.w+i]==-1:#s'il y a bien une mine a cet endroit
                            dc.SetBrush(wx.Brush("red"))
                            dc.DrawRectangle(i*20,j*20,20,20)
                            #incrementation du compteur du joueur
                            index=self.nomJoueurs.index(self.nomJ)
                            self.compteurs[index]+=1
                            self.Compteurs()
                            mm+=1
                            self.parent.client.mySocketEmission.send(str(a),str(b),typ)
                        else:#s'il n'y a pas de mine
                            t=False
                            #affichage d'un message pour dire au joueur qu'il doit passer son tour
                            msg=wx.MessageDialog(self,"\n Il n'y a pas de bombe ici\n Vous perdez votre tour","Rate",wx.OK)
                            rep=msg.ShowModal()
                            msg.Destroy()
                    elif self.game.dec[j*self.game.w+i]==-2:#si la case est marquee par un autre joueur
                        dc.SetBrush(wx.Brush("blue"))
                        mm+=1
                        dc.DrawRectangle(i*20,j*20,20,20)
                    elif self.game.mine[j*self.game.w+i]==-1:#s'il y a une mine sur la case
                        t=False
                        #affichage d'un message pour dire qu'il a perdu
                        msg=wx.MessageDialog(self,"\n Vous avez clique sur une bombe\n Vous avez perdu \n\n Vous allez etre redirige vers l'accueil","Perdu",wx.OK)
                        rep=msg.ShowModal()
                        #envoi de l'information au serveur
                        self.parent.client.mySocketEmission.send("aPerdu\n"+self.nomJ+"\n")
                        self.parent.Destroy()
                        msg.Destroy()
                    else:#sinon
                        dc.SetBrush(wx.Brush("white"))
                        dc.DrawRectangle(i*20,j*20,20,20)
                        k=self.game.grille[j*self.game.w+i]
                        if k!=0 :
                            dc.DrawText("%d"%k,i*20+5,j*20+2)
                        nb+=1

        if nb==30*30-self.nb:#si le nombre de bombes a decouvrir est atteint
            t=False
            index=self.nomJoueurs.index(self.nomJ)
            if self.compteurs[index]==max(self.compteurs):#si le joueur a le score maximal
                #le joueur a gagne
               # msg=wx.MessageDialog(self,"\n Felicitation \n Vous avez gagne \n \nVous allez etre redirige vers l'accueil","Gagne",wx.OK)
               # rep=msg.ShowModal()
                #envoi de l'information au serveur
                self.parent.client.mySocketEmission.send("partieGagnee")
                self.parent.client.mySocketEmission.send(self.nomJoueur)
               # self.parent.Destroy()
               # msg.Destroy()
            else:#sinon
                #un autre joueur a gagne
                ind=self.compteurs.index(max(self.compteurs))
               # msg=wx.MessageDialog(self,"\n Vous avez trouve la derniere bombe \n Mais vous n'avez pas le score maximal \n "+self.Joueurs[ind]+" a gagne \n\n Vous allez etre redirige vers l'accueil","Fin Partie",wx.OK)
               # rep=msg.ShowModal()
                #envoi de l'information au serveur
                self.parent.client.mySocketEmission.send("partieGagnee")
                self.parent.client.mySocketEmission.send(self.Joueurs[ind])
               # self.parent.Destroy()
               # msg.Destroy()

        if t and nom==nomJ:#si rien n'a deja ete envoye et si le joueur est le bon
            #envoi du clic au serveur
            self.parent.client.mySocketEmission.send("clic")
            self.parent.client.mySocketEmission.send(str(a),str(b),typ)
        return mm

    def matrice(self,matrice):#enregistrement de la matrice des mines
       self.game.mine=matrice

    def affichePerdantContinue(self,joueurPerdant):#joueurPerdant a perdu mais la partie continu
        msg=wx.MessageDialog(self,"\n Le joueur " +joueurPerdant+" a perdu \n La partie continue","Un joueur perdant",wx.OK)
        rep=msg.ShowModal()
        self.nomJoueurs.remove(joueurPerdant)#suppression du joueurPerdant de la liste des joueurs et des compteurs
        self.nbJoueurs-=1
        self.compteurs()
        msg.Destroy()

    def affichePerdu(self,joueursGagnants):#affichage des gagnants
        if len(joueursGagnants)==1:
            msg=wx.MessageDialog(self,"\n Le joueur " +nom+" a gagne \n Vous avez donc perdu \n \nVous allez etre redirige vers l'accueil","Perdu",wx.OK)
        else:
            gagnant=''
            for i in range(len(joueursGagnants)):
                gagnant+=joueursGagnants[i]
                if i<len(joueursGagnants)-1:
                    gagnant=+", "
            msg=wx.MessageDialog(self,"\n Les joueur " +gagnant+" a gagne \n Vous avez donc perdu \n \nVous allez etre redirige vers l'accueil","Perdu",wx.OK)
        rep=msg.ShowModal()
        #self.parent.client.mySocketEmission.send("partieGagnee")
        self.parent.Destroy()
        msg.Destroy()

    def afficheGagne(self):#affichage que le joueur a gagne
        msg=wx.MessageDialog(self,"\n Le joueur " +nom+" a perdu \n Vous avez donc gagne !!! Felicitation !!! \n \nVous allez etre redirige vers l'accueil","Gagne",wx.OK)
        rep=msg.ShowModal()
        #self.parent.client.mySocketEmission.send("partieGagnee")
        self.parent.Destroy()
        msg.Destroy()

    def modifCompteur(self,nomJoueur,newVal):#modification du compteur de nomJoueur
        index=self.nomJoueurs.index(nomJoueur)
        self.compteurs[index]
        self.Compteurs()




#Classe Affichage Parties En Cours
class Aff(wx.Panel):
    def __init__(self, parent, ID,nb,parties,type,deb,fin,suiv,prec):
        wx.Panel.__init__(self,parent,ID)
        self.ID=ID
        self.parent=parent
        self.SetSize(parent.GetClientSize())
        self.nb=nb 
        self.parties=parties
        self.deb=deb
        self.fin=fin
        self.suiv=suiv
        self.prec=prec
        Close =wx.Button(self,2,"Fermer",(775,20),size=(100,40))
#        self.init_buffer(type)#initialisation du buffer

        

    def init_buffer(self,type):#initialisation du buffer
        w,h = self.GetClientSize()
        self.buffer = wx.EmptyBitmap(w,h)
        
        if type=="partiesEnCours":#s'il faut afficher la liste des parties disponibles

            PartyEnCours=wx.Button(self,0,"Nouvelle Partie",(20,20),size=(170,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.newParty,id=0)

            Refresh = wx.Button(self,1,"Rafraichir",(420,20),size=(100,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.refresh, id=1)

            Close =wx.Button(self,2,"Fermer",(775,20),size=(100,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.close, id=2)

            if self.nb==0:#s'il n'y a pas de partie disponible
                self.affNonParties()#affichage du message d'information
            else:#sinon
                self.affichagePartieParties()#affichage des parties disponibles
                print "passage Affichage"

        elif type=="newParty":#s'il faut afficher le formulaire de remplissage pour une nouvelle partie
            PartyEnCours=wx.Button(self,0,"Parties en cours",(20,20),size=(170,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.refresh,id=0)

            Close =wx.Button(self,2,"Fermer",(775,20),size=(100,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.close, id=2)

            self.newParty()#affichage du formulaire de remplissage

        elif type=="choix":#s'il faut afficher la demande de confirmation du choix de la partie
            PartyEnCours=wx.Button(self,0,"Parties en cours",(20,20),size=(170,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.refresh,id=0)

            Close =wx.Button(self,2,"Fermer",(775,20),size=(100,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.close, id=2)

            self.choix()#demande de confirmation

    def affNonParties(self):#affichage du fait qu'il n'y a aucune partie disponible             
        cb=wx.StaticText(self,19,"Il n'y a actuellement aucune partie en attente sur le reseau",(100,200),size=(600,60))

    def affichagePartieParties(self):#affichage d'une partie des parties disponibles
        pos=90
        t=70
        ide=200
        for i in range(self.deb,self.fin):
            bt="Nombre de joueurs attendus : "+str(self.parties[i][1])+"\n"
            bt+="Nombre de joueurs deja presents : "+str(self.parties[i][3])+"\n"
            bt+="Difficulte : "+str(self.parties[i][2])
            b=wx.Button(self,ide,bt,(20,pos),(860,t))
            pos+=t
            self.parent.Bind(wx.EVT_BUTTON,self.parent.choixPartie,id=ide)
            ide+=1
            
        if self.prec:#s'il faut afficher le bouton precedent
            precedent=wx.Button(self,110,"Parties Precedents",(20,600),(150,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.prec,id=110)
        if self.suiv:#s'il faut afficher le bouton suivant
            suivant=wx.Button(self,100,"Parties Suivantes",(730,600),(150,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.suivant,id=100)
    

    def newParty(self):#affichage du formulaire de nouvelle partie

        cb=wx.StaticText(self,19,"Entrez les donnees pour une nouvelle partie",(325,150),size=(600,60))
        
        cb=wx.StaticText(self,20,"Pseudo",(150,225),size=(260,30))
        cb=wx.StaticText(self,21,"Nom de la partie",(150,265),size=(260,30))
        cb=wx.StaticText(self,22,"Nombre de joueurs attendus (entre 2 et 8)",(150,305),size=(260,30))
        cb=wx.StaticText(self,23,"Difficulte",(150,345),size=(260,30))

        txtP=wx.TextCtrl(self,30,"",(500,220),size=(250,30),style=wx.TE_PROCESS_ENTER)
        self.parent.Bind(wx.EVT_TEXT,self.parent.textPseudo,txtP)
        txtNP=wx.TextCtrl(self,31,"",(500,260),size=(250,30),style=wx.TE_PROCESS_ENTER)
        self.parent.Bind(wx.EVT_TEXT,self.parent.textNomPartie,txtNP)
        txtNb=wx.TextCtrl(self,32,"",(500,300),size=(250,30),style=wx.TE_PROCESS_ENTER)
        self.parent.Bind(wx.EVT_TEXT,self.parent.textNb,txtNb)
        radDiff=wx.RadioBox(self,33,choices=["Facile","Moyen","Difficile"],style=wx.RA_SPECIFY_ROWS,majorDimension=0,pos=(500,340),size=(250,100))
        self.parent.Bind(wx.EVT_RADIOBOX,self.parent.diff,radDiff)
        self.parent.difficulte=radDiff.GetSelection()

        Val=wx.Button(self,50,"Valider",(440,500),(100,40))
        self.parent.Bind(wx.EVT_BUTTON,self.parent.val,id=50)

    def choix(self):#afichage de la confirmation et demande de pseudo
        cb=wx.StaticText(self,19,"Vous avez choisi la partie :",(180,150),size=(600,60))
    
        cb=wx.StaticText(self,21,"Nom de la partie",(150,220),size=(260,30))
        cb=wx.StaticText(self,22,"Nombre de joueurs attendus",(150,260),size=(260,30))
        cb=wx.StaticText(self,23,"Difficulte",(150,300),size=(260,30))
        cb=wx.StaticText(self,-1,"Votre pseudo",(150,350),size=(260,30))

        cb=wx.StaticText(self,30,self.parties[0],(500,220),size=(250,30))
        cb=wx.StaticText(self,31,str(self.parties[1]),(500,260),size=(250,30))
        cb=wx.StaticText(self,32,str(self.parties[2]),(500,300),size=(250,30))
        txtP=wx.TextCtrl(self,31,"",(500,350),size=(250,30),style=wx.TE_PROCESS_ENTER)
        self.parent.Bind(wx.EVT_TEXT,self.parent.textPseudo,txtP)


        Val=wx.Button(self,50,"Valider",(440,500),(100,40))
        self.parent.Bind(wx.EVT_BUTTON,self.parent.val,id=50)

        

#Classe pour lier le client et rejoindre le serveur	
class GameReseauFrame(wx.Frame):
    def __init__(self, parent, ID, title, pos=wx.DefaultPosition,size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE):
	
        wx.Frame.__init__(self, parent, ID, title, pos, size, style)
        self.SetAutoLayout(True)
        self.Panel=None
        self.msg=None
        self.partie=None
        self.client=None

        #self.parties=[["partie1",2,1,1,"Joueur1"],["partie2",3,1,2,"joueur1","joueur2"],["partie3",3,2,1,"joueur1"],["partie4",3,1,1,"joueur1"],["partie5",3,1,1,"joueur1"],["partie6",3,1,1,"joueur1"],["partie7",3,1,1,""],["partie8",3,1,1,""]]
        #print l
        #self.affichagePartieDisp(8,self.parties)
        #self.choixPartie()
        #self.affichagePartieDisp(0,[])
        #self.newParty()
        
        #self.client=debutClient(port)
        #mySocketEmission.send("")

        #self.partie=["nomPartie",8,1,"nomJoueur1","nomJoueur2","3","4","5","6","7","8"]
        #self.rejoindrePartie()

    def initialisationClient(self,port):#initialisation de la liaison client-serveur
        #self.client=debutClient(port,self)
        debutClient(port,self)
        #self.client.mySocketEmission.send("listePartiesEnAttente")
    
        
    def affichagePartieDisp(self,nb,parties):#affichage des parties disponibles sur le reseau
        self.nb=nb
        self.parties=parties
        #print self.nb
        #print self.parties

        #print "passage affichagePartieDisp"
        if nb==0:#s'il n'y a aucune partie disponible sur le reseau
            if console:
                self.affichagePasParties()
            else:
                self.Panel=Aff(self,10,nb,[],"partiesEnCours",0,0,0,0)#affichage d'un message comme quoi il n'y a pas de partie disponible                 
                         
        elif nb>7:#si le nombre de parties disponibles est sup. a 7 (taille limite d'affichage)
            self.deb=0
            self.fin=7

            if console:#si affichage seulement console
                self.affichageParties()
            else:
                self.Panel=Aff(self,-1,self.nb,self.parties,"partiesEnCours",0,7,True,False)#affichage des 7 premieres parties avec un bouton Suivant
 
        else:#sinon
            self.deb=0
            self.fin=nb

            if console:#si affichage slt console
                self.affichageParties()
            else:
                self.Panel=Aff(self,-1,self.nb,self.parties,"partiesEnCours",0,nb,False,False)#affichage de toutes les parties


    def suivant(self,evt):#quand le joueur a clique sur le bouton suivant (cas ou le nombre de parties disponibles est superieur a 7)
        self.deb=self.fin
        if self.fin+7>self.nb:#si le nombre de parties restantes a afficher est inferieur a 7
            self.fin=self.nb
            suiv=False#pas besoin d'un bouton suivant
        else:#sinon
            self.fin+=7
            suiv=True#besoin d'un bouton suivant
        self.panel=Aff(self,-1,self.nb,self.parties,"partiesEnCours",self.deb,self.fin,suiv,True)#affichage des parties suivantes avec 1 bouton precedent et/ou pas un bouton suivant

    def prec(self,evt):#quand le joueur a clique sur le bouton precedent (cas ou le nombre de parties disponibles est superieur a 7)
        self.fin=self.deb
        self.deb-=7
        if self.deb==0:#si on arrive aux premieres parties
            prec=False #pas besoin d'un bouton precedent
        else:#sinon
            prec=True#besoin d'un bouton precedent
        self.panel=Aff(self,-1,self.nb,self.parties,"partiesEnCours",self.deb,self.fin,True,prec)#affichage des parties precedentes avec 1 bouton suivant et/ou pas un bouton precedent


    def refresh(self,evt): #quand le joueur clique sur le bouton "Rafraichir"
        self.client.mySocketEmission.send("listePartiesEnAttente")#demande au serveur de la nouvelle liste de parties disponibles


    def close(self,evt):#quand le joueur choisi de quitter la partie
        self.Destroy()


    def choixPartie(self,evt):#quand le joueur a choisi une partie qui l'interesse
        #Recuperer le numero du bouton clique
        #print evt.
        #print "choixPartie"
        if not console:
            self.num=evt.GetId()#recuperation du numero d'identifiant du bouton
        #print num
            self.num=self.num-(200-self.deb)#transformation du numero pour obtenir le vrai numero de la partie
        print num
        
        #enregistrement de donnees de la partie
        self.nomJoueur=""
        self.nomPartie=self.parties[self.num][0]
        self.nbJoueursAttendus=self.parties[self.num][1]
        self.difficulte=self.parties[self.num][2]
        self.Joueurs=self.parties[self.num][4::]
        self.partie=[self.nomPartie,self.nbJoueursAttendus,self.difficulte,self.Joueurs]#rassemblement des donnees

        self.panel=Aff(self,-1,1,self.partie,"choix",0,0,0,0)#demande au joueur si c'est bien la partie qu'il a choisi et d'entrer son pseudo pour la partie                    


        #envoie des informations au serveur
        self.client.mySocketEmission.send("numPartieChoisie\n")
        self.client.mySocketEmission.send(str(num)+"\n")
        self.client.mySocketEmission.send("nomJoueur\n")
        self.client.mySocketEmission.send(self.nomJoueur+"\n")

        if self.nbJoueursAttendus==len(self.Joueurs):#si le nombre de joueurs attendus est atteint
            self.rejoindre()#la partie peut demarrer
        else:#sinon
            self.msg=wx.MessageDialog(self,"\n Tous les joueurs attendus ne sont pas la \n Veuillez attendre que tous les joueurs soient la","Attente")#il faut faire attendre le joueur


    def newParty(self,evt):#quand le joueur choisi d'initialiser une nouvelle partie
        self.nomJoueur=""
        self.nomPartie=""
        self.difficulte=""
        self.nbJoueursAttendus=""

        self.panel=Aff(self,-1,0,[],"newParty",0,0,0,0)#affichage d'une fenetre ou le joueur entre les caracteristiques de la partie


    def textPseudo(self,evt):#enregistrement du pseudo du joueur
        self.nomJoueur=evt.GetString()
        self.Joueurs.append(self.nomJoueur)
        if self.partie!=None:#si c'est dans le cas ou slt le pseudo du joueur etait demande (confirmation de choix de partie)
            self.partie[3].append(self.nomJoueur)

    def textNomPartie(self,evt):#enregistrement du nom de la partie
        self.nomPartie=evt.GetString()

    def textNb(self,evt):#enregistrement du nom de joueurs attendus
        if re.search(r"^[0-9]+$",evt.GetString())!=None:#si le nb entree est bien un entier
            self.nbJoueursAttendus=int(evt.GetString())
        else:#sinon
            msg=wx.MessageDialog(self,"\n Le caractere entree n'est pas un entier","Erreur",wx.OK|wx.ICON_ERROR)
            rep=msg.ShowModal()
            msg.Destroy()
            

    def diff(self,evt):#enregistrement de la difficulte de la partie
        self.difficulte=evt.GetSelection()

    def val(self,evt):#quand le joueur qui initialise une partie, clique sur valider 
        if self.nomJoueur!="" and self.nomPartie!="" and self.nbJoueursAttendus!="" and self.difficulte!="":#si toutes les donnees entrees sont correctes
            print "attente joueur"
            #envoi de l'information du serveur
            self.client.mySocketEmission.send("partie\n")
            self.client.mySocketEmission.send(self.nomPartie+","+str(self.nbJoueursAttendus)+","+str(self.difficulte)+","+str(1)+","+self.nomJoueur)
            #le joueur doit attendre que le nb de joueurs attendus soit atteint
            self.msg=wx.MessageDialog(self,"\n Vous devez attendre que d'autres joueurs rejoignent la partie","Attente")
 
        else:#sinon
            #Affichage d'une fenetre d'erreur
            msg=wx.MessageDialog(self,"\n Au moins un des champs n est pas ou mal renseigne","Erreur",wx.OK|wx.ICON_ERROR)
            rep=msg.ShowModal()
            msg.Destroy()
            print "Un des champs non renseigne"
    
    def debutPartie(self,listeJoueurs):#la partie peut commencer, tous les joueurs attendus ont rejoint la partie
        if self.msg!=None:#si une fenetre d'attente etait ouverte
            self.msg.Destroy()#destruction
        self.Joueurs=listeJoueurs#enregistrement de la liste finale des joueurs
        self.partie=[self.nomPartie,self.nbJoueursAttendus,self.difficulte,self.Joueurs]#enregistrement de la partie
        self.rejoindre()#demarrage de la partie

    def Matrice(self,matrice):#enregistrement de la matrice dans le jeu
        self.jeu.matrice(matrice)

    def Tour(self):#c'est au joueur de jouer
        self.jeu.atoi=True
        print "tour"
        msg=wx.MessageDialog(self,"\n C'est votre tour","A vous de joueur",wx.OK)
        rep=msg.ShowModal()
        msg.Destroy()
        
        #p-e affichage d'une fenetre lui disant qu'il peut jouer
        #il faudrait aussi pouvoir bloquer clic gauche et clic droit tant que ce n'est pas son tour

    def modifCompteur(self,nomJoueur,newVal):#modification du compteur de nomJoueur avec newVal
        self.jeu.modifCompteur(nomJoueur,newVal)
        #print nomJouer, newVal

    def decouvrement(self,clic,typ,nom):#decouvrement de la grille en fonction du type de clic
        self.jeu.decouvrir(clic[0],clic[1],nom,typ)


    def aPerdu(self,joueurPerdant):#joueurPerdant a perdu mais le jeu peut continuer
        self.jeu.affichePerdantContinue(joueurPerdant)


    def finPartie(self,joueursGagnants):#la partie est finie, joueursGagnants ayant gagne
        if self.nomJoueur in joueursGagnants:
            self.jeu.afficheGagne()
        else:
            self.jeu.affichePerdu(joueursGagnants)

    def rejoindrePartie(self):#la partie commence
        menubar=wx.MenuBar()
       
        menu =wx.Menu(style=wx.MENU_TEAROFF)
        menubar.Append(menu,"&File")

        menu1=wx.Menu(style=wx.MENU_TEAROFF)
        menu1.Append(3,"Facile")
        menu1.Append(4,"Moyen")
        menu1.Append(5,"Difficile")
        
        menu.AppendMenu(wx.ID_OPEN,"New",menu1)
        menu.AppendSeparator()
        menu.Append(wx.ID_EXIT,"&Quit","Quit")
        
        self.SetMenuBar(menubar)
        
        self.statusBar = self.CreateStatusBar() #creation de la barre d'etats
        self.CreateStatusBar()
        self.SetStatusText("Cliquez sur la grille pour jouer")
       
        self.jeu=DeminWindowReseau(self,-1,self.partie,self.nomJoueur)#lancement de la partie





class Console:
    
    def __init__(self,parent):
        self.partie=None
        self.client=None
        self.parent=parent

    def initialisationClient(self,port):#initialisation de la liaison client-serveur
        #self.client=debutClient(port,self)
        debutClient(port,self)
        #self.client.mySocketEmission.send("listePartiesEnAttente")

    def affichagePartieDisp(self,nb,parties):#affichage des parties disponibles sur le reseau
        self.nb=nb
        self.parties=parties
        #print self.nb
        #print self.parties

        print "passage affichagePartieDisp"
        if nb==0:#s'il n'y a aucune partie disponible sur le reseau
            self.affichagePasParties()
        else:
            self.affichageParties()


    #fonctions pour affichage Console
    def affichagePasParties(self):
        print "Il n'y a pour le moment aucune partie en cours"
        print "Pour joueur, vous devez donc creer une nouvelle partie : il faut donc entrer New ou attendre de nouvelles parties (Refresh)"
        print "NB : pour quitter, entrez Quit"
        msg = raw_input('>> ')
        pasOk=True
        while pasOk:
            if msg=="New":
                self.NouvellePartie()
                pasOk=False
            elif msg=="Refresh":
                self.Rafraichir()
                pasOk=False
            elif msg=="Quit":
                print "Au revoir"
                pasOk=False
                sys.exit(-1)
                self.Destroy()
            else:
                print "Vous n'avez pas entrer une valeur correcte, veuillez recommencer"

    def affichageParties(self):
        print "Les parties disponibles actuellement sur le reseau sont : \n"
        for i in range(self.nb):
            print "Numero  : "+str(i)+"\nNombre de joueurs attendus : "+str(self.parties[i][1])+"\nNombre de joueurs deja presents : "+str(self.parties[i][3])+"\nDifficulte : "+str(self.parties[i][2])+"\n"
        print "Choisissez un numero"
        print "Vous pouvez aussi rafraichir l'affichage (Refresh), initialiser une nouvelle partie (NewParty) ou quitter (Quit)"
        msg = raw_input('>> ')
        pasOk=True
        while pasOk:
            if re.search("^[0-9]+$",msg)!=None:
                self.choixPartie(int(msg))
                pasOk=False
            elif msg=="Refresh":
                self.Rafraichir()
                pasOk=False
            elif msg=="NewParty":
                self.nouvellePartie()
                pasOk=False
            elif msg=="Quit":
                print "Au revoir"
                pasOk=False
                sys.exit(-1)
                self.Destroy()
            else:
                print "Vous n'avez pas entrer une valeur correcte, veuillez recommencer"

                

    def nouvellePartie(self):
        print "\n\n  Entrez les caracteristiques de la partie"
        print "NB : entrer Quit pour quitter"

        print "Votre pseudo"
        msg = raw_input('>> ')
        if msg=="Quit":
            print "Au revoir"
            pasOk=False
            sys.exit(-1)
            self.Destroy()
        else:
            self.nomJoueur=msg

        print "\nNom de la partie"
        msg = raw_input('>> ')
        if msg=="Quit":
            print "Au revoir"
            sys.exit(-1)
            self.Destroy()
        else:
            self.nomPartie=msg

        print "\nNombre de joueurs attendus (entre 2 et 8)"
        msg = raw_input('>> ')
        pasOk=True
        while pasOk:
            if re.search("^[0-9]+$",msg)!=None:
                self.nbJoueursAttendus=int(msg)
                pasOk=False
            elif msg=="Quit":
                print "Au revoir"
                pasOk=False
                sys.exit(-1)
                self.Destroy()
            else:
                print "Vous n'avez pas entre une valeur correcte, veuillez recommencer"

        print "\nDifficulte (Facile, Moyen ou Difficile)"
        msg = raw_input('>> ')
        pasOk=True
        if msg=="Quit":
            print "Au revoir"
            sys.exit(-1)
            self.Destroy()
        else:
            self.difficulte=msg

        self.client.mySocketEmission.send("partie\n")
        self.client.mySocketEmission.send(self.nomPartie+","+str(self.nbJoueursAttendus)+","+str(self.difficulte)+","+str(1)+","+self.nomJoueur)

        print "Vous devez maintenant attendre que "+str(self.nbJoueursAttendus-1)+" joueur(s) rejoignent cette partie\n"
        
            
    def choixPartie(self,num):
        print "\n\nVous avez choisi la partie :"
        print "Numero  : "+str(num)+"\nNombre de joueurs attendus : "+str(self.parties[num][1])+"\nNombre de joueurs deja presents : "+str(self.parties[num][3])+"\nDifficulte : "+str(self.parties[num][2])+"\n"
        print "Entrez votre pseudo"
        print "NB : Vous pouvez aussi quitter (Quit)"
        msg = raw_input('>> ')
        if msg=="Quit":
            print "Au revoir"
            pasOk=False
            sys.exit(-1)
            self.Destroy()
        else:
            self.nomJoueur=msg

        #self.client.SendChoiceParty(num,self.nomJoueur)
        
        self.client.mySocketEmission.send("numPartieChoisie\n")
        self.client.mySocketEmission.send(str(num)+"\n")
        self.client.mySocketEmission.send("nomJoueur\n")
        self.client.mySocketEmission.send(self.nomJoueur+"\n")

        self.nomPartie=self.parties[num][0]
        self.nbJoueursAttendus=self.parties[num][1]
        self.difficulte=self.parties[num][2]
        self.Joueurs=self.parties[num][4::]
        self.Joueurs.append(self.nomJoueur)
        self.partie=[self.nomPartie,self.nbJoueursAttendus,self.difficulte,self.Joueurs]

        if self.parties[num][1]==self.parties[num][3]+1:
            print "La partie peut commencer"
            print self.partie
            print self.nomJoueur
            self.win=DeminConsolReseau(self.partie,self.nomJoueur)
            #self.win=ReseauFrame(None,-1,"Demineur En Reseau",size=(900,665),style=wx.DEFAULT_FRAME_STYLE)#lancement de l'application
            #self.SetTopWindow(self.win)
            #self.win.Show(True)
            #self.win.Panel=DeminWindowReseau(self.win,-1,self.partie,self.nomJoueur)
            print "j'ai pas plante au Panel"
        else:
            print "Vous devez attendre encore "+str(self.parties[num][1]-self.parties[num][3])+" joueurs avant de debuter la partie"


class ReseauFrame(wx.Frame):
    def __init__(self, parent, ID, title, pos=wx.DefaultPosition,size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE):
        wx.Frame.__init__(self, parent, ID, title, pos, size, style)
        self.SetAutoLayout(True)
        self.Panel=None
        
        NewGame = wx.Button(self,1,"Partie en Solo",(10,10),(150,100))
        self.Bind(wx.EVT_BUTTON,self.fnewgame, id=1)

        cb=wx.StaticText(self,23,"Difficulte",(150,345),size=(260,30))

    def fnewgame(self,evt):
        print "fnewgame"


class DeminConsolReseau:

    def __init__(self,partie,nomJ):
        print "qd?"
        self.wm=30
        self.hm=30

        #recuperation des donnees relatives a la partie
        self.nomPartie=partie[0]
        self.nbJoueurs=partie[1]
        self.difficulte=partie[2]
        self.nomJoueurs=partie[3]
        self.compteurs=[0]*self.nbJoueurs
        self.nomJ=nomJ
        
        #determine si joueur doit demarrer la partie ou pas
        self.premier=False
        self.atoi=False
        if self.nomJ==self.nomJoueurs[0]:
            self.premier=True
            self.atoi=True

        if re.search("^[0-9]",self.difficulte)!=None:
            self.difficulte=int(self.difficulte)
            self.nb=self.difficulte*45-(self.difficulte-1)*5#determination du nb de mines dans le jeu
        elif self.difficulte=="Facile":
            self.nb=45
        elif self.difficulte=="Moyen":
            self.nb=85
        else:
            self.nb=120

        print self.nb
        print self.difficulte

        self.game=pyDemin(30,30,self.nb)#initialisation du jeu en lui-meme

        print "plantage"
        #self.parent=parent

        self.init_buffer()#initialisation du buffer

    def clicGauche(self):
        print "Clic gauche"

    def clicDroit(self):
        #penser a modifier le compteur et tester s'il y a bombe ou pas
        print "Il n'y a pas de bombe ici\nVous passez donc votre tour\n"
                  
    def init_buffer(self):
        s="   "
        for j in range(self.wm):
            if j>=10:
                s+=" "+str(j)+" "
            else:
                s+=" "+str(j)+"  " 
        s+="\n"
        for j in range(self.wm):
            s+="----"
        s+="---"
        s+="\n"
        for i in range(self.hm):
            if i>=10:
                s+=str(i)+"|"
            else:
                s+=" "+str(i)+"|"
            for j in range(self.wm):
                s+="   |"
            s+="\n"
            for j in range(self.wm):
                s+="----"
            s+="---"
            s+="\n"
        print s
        self.Compteurs()
        
        if self.premier:
            self.pourClic()
        else:
            print "Attente des jeux des autres joueurs"
            

    def pourClic(self):
        print "\nChoisissez un type de 'clic' (left ou right)"
        print "NB : Quit pour quitter"
        while pasOk:
            msg = raw_input('>> ')
            if msg=="Quit":
                print "Au revoir"
                pasOk=False
                sys.exit(-1)
                self.Destroy()
            elif msg=="left":
                typ=msg
                pasOk=False
            elif msg=="right":
                typ=msg
                pasOk=False
            else:
                print "Vous n'avez pas entre une valeur correcte"
        print "\nChoisissez les coordonnees du 'clic' (x,y avec x en colonne et y en ligne)"
        print "NB : Quit pour quitter"
        while pasOk:
            msg = raw_input('>> ')
            if msg=="Quit":
                print "Au revoir"
                pasOk=False
                sys.exit(-1)
                self.Destroy()
            elif re.search("^[0-9]+,[0-9]+$",msg)!=None:
                l=msg.split(",")
                x=int(l)
                y=int(l)
                if x<0 or self.lm<=x or y<0 or self.wm<=y:
                    print "Vous n'avez pas entre une valeur correcte"
                else:
                    pasOk=False
                    self.clic(x,y,typ)
            else:
                print "Vous n'avez pas entre une valeur correcte"

    def clic(self,x,y,typ):
        if typ=="left":
            self.game.decouvre(x,y,typ)
        else:
            self.game.aamine(x,y,typ)
        self.buffer(x,y,typ)

    def buffer(self,a,b,typ):
        t=True
        nb=0
        mm=0
        mT=0
        s=""
        for j in range(self.wm):
            s+=" "+str(j)+" "
        s+="\n"
        for j in range(self.wm):
            s+="---"
        s+="\n"
        for i in range(self.hm):
            s=str(i)+"|"
            for j in range(self.wm):
                if self.game.dec[j*self.game.w+i]==0:
                    s+="   |"
                elif self.game.dec[j*self.game.w+i]==-1:
                    if self.game.mine[j*self.game.w+i]==-1:
                        s+=" x |"
                        mm+=1
                    else:
                        t=False
                        print "Il n'y a pas de bombe ici\nVous passez donc votre tour\n"
                        s+="  "
                elif self.game.dec[j*self.game.w+i]==-2:
                    s+=" * |"
                    mT+=1
                elif self.game.mine[j*self.game.w+i]==-1:
                    t=False
                    print "Vous avez choisi une case avec une bombe, vous avez perdu"
                    self.parent.client.mySocketEmission.send("aPerdu\n"+self.nomJ+"\n")
                else:
                    k=self.game.grille[j*self.game.w+i]
                    if k!=0:
                        s+=" "+str(k)+" |"
                    nb+=1
                s+="\n"

        if nb==self.hm*self.wm-self.nb:
            t=False
            index=self.nomJoueurs.index(self.nomJ)
            if self.compteurs[index]==max(self.compteurs):
                print "Vous avez gagne"
                self.parent.client.mySocketEmission.send("finPartie\n")
                self.parent.client.mySocketEmission.send(self.nomJ+"\n")
            else:
                print "Vous avez perdu"
                ind=self.nomJoueurs.index(max(self.compteurs))
                self.parent.client.mySocketEmission.send("finPartie\n")
                self.parent.client.mySocketEmission.send(self.nomJoueurs[ind]+"\n")
         
        if t:
            print s+"\n\n"
            self.Compteurs()
            if nom==nomJ:
                self.parent.client.mySocketEmission.send("clic\n")
                self.parent.client.mySocketEmission.send(str(a)+","+str(b)+","+typ+"\n")
            if self.aToi:
                self.pourClic()
            else:
                print "Attente du jeu des autres joueurs"

    
    def Compteurs(self):
        print "Etats des autres joueurs"
        for i in range(self.nbJoueurs):
            print self.nomJoueurs[i]+" : "+str(self.compteurs[i])+"\n"
